Automatic Pre-detection of Potential Coding Issues and Recommendation for Resolution Actions

ABSTRACT

A tool for automatic pre-detection of potential software product impact according to a statement placed in a software development system, and for automatically recommending for resolutions which accesses a repository of information containing a history of changes and effects of the changes for a software project; using a received a statement in natural language to perform a natural language search of the repository; according to the findings of the search of the repository, using a machine learning model to compose an impact prediction regarding the received statement relative to the findings; and automatically placing an advisory notice regarding to the impact prediction into the software development system, wherein the advisory notice is associated with the received statement.

FIELD OF THE INVENTION

This is a continuation application of U.S. patent application Ser. No.15/367,088, our docket AUS920130139US2, filed on Dec. 1, 2016, which wasa continuation of U.S. patent application Ser. No. 14/028,048, ourdocket AUS920130139US1, filed on Sep. 16, 2013, now U.S. Pat. No.9,519,477, all by George H. Champlin-Scharff, et al. The presentinvention relates to software development tools and software qualityimprovement processes.

BACKGROUND OF INVENTION

Many software products are developed, maintained, and improved through aproject management process, which is generally well-understood andsupported by formal software engineering education programs. Manyseparate, and some integrated, tools have been developed, which are usedby software developers to automate, track, and control the configurationof released and delivered software products.

Referring now to FIG. 1 b, a generalized process flow of softwaredevelopment is shown, in which software requirements (103) for newproducts and new features to existing software products are receivedinto a formal software development process (110). The source code andcompiler directive files are then received (111) or “checked in” to aconfiguration management system, subsequent to which one or more testcases are executed (112) against the code to verify one or more of therequirements are met and to identify any errors in the code.

Modules, methods, libraries, etc., which pass the test are then promotedto a released status (113), so that they may be deployed, installed,sold, distributed, etc. (114), for end use.

During the life cycle of the software product, one or more bug reportsor feature requests may be received (104), which in turn are reflectedin new or revised requirements (103), and the cycle (110-114) isrepeated. This is a generalized view of the software developmentprocess, of course, but it serves the purpose for the presentdisclosure.

SUMMARY OF THE INVENTION

Embodiments according to the present invention provide a tool forautomatic pre-detection of potential software product impact accordingto a statement placed in a software development system, and forautomatically recommending for resolutions which accesses a repositoryof information containing a history of changes and effects of thechanges for a software project; using a received a statement in naturallanguage to perform a natural language search of the repository;according to the findings of the search of the repository, using amachine learning model to compose an impact prediction regarding thereceived statement relative to the findings; and automatically placingan advisory notice regarding to the impact prediction into the softwaredevelopment system, wherein the advisory notice is associated with thereceived statement.

BRIEF DESCRIPTION OF THE DRAWINGS

The figures presented herein, when considered in light of thisdescription, form a complete disclosure of one or more embodiments ofthe invention, wherein like reference numbers in the figures representsimilar or same elements or steps.

FIG. 1a illustrates an overall embodiment according to the presentinvention, including a plurality of optional features and advantages.

FIG. 1b represents a general process of software development andmaintenance.

FIG. 2 depicts the gathering of natural language text from a variety ofsources, in this particular scenario, from requirements documents.

FIG. 3 shows a logical process for processing a new requirement or achange to a requirement, to pre-detect possible software errors thatmight be induced into the software product, and to automatically providean advisory regarding potential interventional steps or approaches.

FIG. 4 reflects a similar process for pre-detecting and advising for newbug reports.

FIG. 5 also reflects a similar process to that of FIG. 3, except forresponding to a proposed new or changed work item.

FIG. 6 illustrates a generalized computing platform suitable forcombination with program instructions to perform logical processes suchas those shown in FIGS. 1 a, 1 b and 2-5 to yield a computer systemembodiment according to the present invention.

DETAILED DESCRIPTION OF EMBODIMENTS OF THE INVENTION

The present inventors have recognized a problem in the art, which iscurrently unrecognized and unsolved. During software development ofcomplex software products, many different people involved in thedevelopment, test, configuration, and deployment processes encounter ofthe same issues at different times. For example, one developer mightchange a setting or method, causing problems with the code. Then, amonth later, another developer might do exactly the same thing.

Such events are usually discussed in “bug” tracking tools, softwaredevelopment planning tools, developer code comments, and othersolutions. However, the present inventors have realized that the currentsearch tools are inadequate to find problem reports, which discuss thesame root problem but may use different terminology, situations andexamples to do so.

The inventors have recognized that the limitations of such exercisessearching for problem and bug discussions arise from the fact that thesearch engines conduct their searching and scoring too literally,looking for exact or similar terminology. So, the present inventors haveset out, in a first advantage of the present invention, to develop animproved software problem discussion search methodology and a tool that“pre-detects” potential coding issues using Natural Language Processing(NLP).

Additionally, the present inventors have recognized that test casegeneration is typically manually performed, and it is a time consumingphase of the development process. Further, the quality of test casesvaries depending on the authors' skill sets and how well the authorknows the product being tested and its potential problem areas. Ahighly-skilled, highly-experienced test case author comes to know thepatterns or mistakes of a software team and the areas of vulnerabilitiesof a particular software product, and can use intuition to guide his orher test cases to exercise those areas of the product as it is evolvedand updated. Existing test cases are typically carried over acrossmultiple releases and revisions of the software product, and such legacytest cases can become outdated due to feature changes and enhancements.Moreover, it is often being overlooked in everyday work to leveragedefects discovered previously, sometimes by another person, and applythe related test cases to other parts of the product. This can beparticularly true in a large organization, especially in organizationsthat work across disparate time zones, geographies, and developmentmethodologies.

In a second advantage of the present invention, the inventors provide ameans and mechanism to intelligently re-use test cases, abandoning thosethat are completely outdated or obsoleted, re-using those that are stillapplicable, and recommending modifications to those that are stillpartially applicable but partially inapplicable.

Generalities of Natural Language Searching

Embodiments of the present invention preferably employ natural languagesearching. For clarity, we present some background information ofnatural language searching, and compare it to the more commonplacekeyword searching.

First, we should clarify what we mean by “natural language”, as some inthe art have pointed out that even this term is up for debate, such asWinfred Philips in “Introduction to Logic for ProtoThinker” (2006). Forthe purposes of this disclosure, we are referring to user input into auser interface on a computer which allows for natural queries ratherthan structured queries. For example, a structured query to search forall patents that relate to stack overflow errors might look somethinglike [stack NEAR (overflow OR “over flow”)]. This would search forinstances of keyword “stack” within a pre-set number of words (e.g.,“near” operator) of the keyword “overflow” or near the keywordcombination “over flow”.

A natural language input, however, for the same query would not requiresuch computer-based syntax, rather it would allow for an input such as“find me patents about stack overflow errors”. A natural languageprocessor (NLP) would parse this input, apply a plethora of rules,grammars, lexicons, synonym lists, etc., to extract a first constituentterm “find”, which could be mapped to a computer command “search”. TheNLP would also use its resources to determine that the constituent term“stack overflow” may also be expressed in the searched corpus asconstituent terms “stack over flow”, “over flow the stack”, “overflow astack”, etc., using synonym lists, grammars, etc.

Also, it should be noted that the searched corpus may or may not be innatural language. In the context of the present invention, the corpusmay include software source code as well as release notes. The latter,release notes, may be in document form, such as a word processorelectronic files, and thus could be expected to contain natural languagestatements. The former, software source code, may have structuredstatements, e.g., software statements such as C, C++ or Java statements,as well as natural language statements such as programmer comments andtext which may be printed to a user output device.

For the purposes of the present disclosure, we presume that both theuser input and the searched corpus contain natural language statements.And, for the purposes of the present disclosure, it is presumed that thereader is familiar with natural language processing and available NLPproducts, such that the present disclosure provides additionalinformation which uses or calls NLP resources as a platform, but doesnot necessarily include NLP within the invention embodiments. Anysuitable NLP processor may be employed to search a corpus in theinventive manner disclosed in the following paragraphs.

Therefore, our phrase NLP searching shall mean to receive an inputphrase from a user that is expressed in natural language, to apply NLPto that input phrase to extract symbols from it, and then to search onthose symbols in a corpus, wherein the corpus also contains naturallanguage and/or structured language.

NLP searching is usually much broader than keyword searching for severalreasons. First, it allows the user to express his or her needs in amanner more suitable for the user, and less constrained by systemrequirements. This increases the likelihood that the search query itselfis accurately directed towards the desired information. Second, byextracting the symbols from the natural language input, the search andproceed not only on the symbols, but also on their aliases and synonyms.In the foregoing example, the term “stack” may be searched (a symbolfound in the original user's input query), and the synonym “heap” mayalso be searched according to a synonym list. And, the term “overflow”may be searched as well as an antonym “underflow”. For a user to achievethe same search breadth, he or she would have to have expertise to crafta much more complicated structured query and would have to be diligentenough to look up many synonyms and antonyms, as well as to formulatesimilarly-meaningful alternative phrases.

Therefore, for the purposes of this disclosure, natural languagesearching shall mean receiving a natural language expression as ansearch query input, applying one or more NLP techniques includingdeductive logic, inductive logic, validity and soundness checks, rulesof though (e.g., principle of contradiction, law of excluded middle,etc.), truth functionalities (e.g. Modus Ponens, Modus Tollens,hypothetical syllogism, denying an antecedent, affirming a consequent,etc.), predicate logic, sorites arguments, ethymemes, syntacticanalysis, semantic analysis, and pragmatics. Syntactic analysis maycontain one or more parsers, such as noise-disposal parsers,state-machine parsers, and definite clause parsers, and it may includepre-determined and updateable grammars (e.g. recognizable grammarstructures), such as context-free notations (e.g. Backus-Naur forms,etc.). A semantic analyzer may, based on the results of the syntacticanalysis or interactively operating with syntactic analysis, determinesthe meaning of a phrase, statement or sentence. Most semantic analyzersattempt to re-write the phrase, statement or sentence into acontext-free form so that it can be more readily found in a lexicon andmapped to an intended or implicit meaning. Pragmatics then operates tofurther reduce remaining ambiguities by applying reasonable domainscope, resolving anaphoras, and using inferencing to generatealternative expressions for the same meaning (upon which the search canbe performed, as well).

These and other techniques are known in the art among academics,computer scientists, linguistic researchers, and product developers suchthat one may use NLP for other applications by obtaining an appropriateNLP product and integrating its functions via an Application ProgrammingInterface (API), for example. As such, we will not provide furtherdetails into NLP, as it is suffice to say that embodiments of thepresent invention employ one or more such available products. IBM'sWatson currently has a proprietary interface for application programs,and a number of open API's are available for applications developers toother NLP platforms and products, such as Stremor Automated Summary andAbstract Generator™, Repustate Sentiment and Social Media Analytics™,Skyttle, SpringSense Meaning Recognition™, etc.

Natural language searching can be further enhanced by the addition oflanguage models which employ Artificial Intelligence (AI) techniques sothat their performance converges on a desired outcome throughout usage.For example, if in a first search, a user or administrator marks certainfound items as “better” and certain other found items as “worse”, and AIengine can then adjust certain parametric weights to the NLP methods andprocesses to favor the rules and methods which generated the “better”outputs and to disfavor the rules and methods which generated the“worse” outputs. In a second search, the use may again mark some resultsas better and others as worse, and the AI engine can further tune theparametric weights, and so forth. Over time and usage, the NLP searchingwill become more and more accurate at finding and outputting the kind ofresults the user or administrator desires by “learning” the user's oradministrator's preferences.

System-Level Description of Embodiments

Turning to FIG. 1 a, the process of FIG. 1b is annotated to show thedifferent points, at which embodiments of the present invention may beadvantageous during traditional software development and projectmanagement. Embodiments may implement any one or more of the features inallowing pre-detection and advisory intervention notices responsive tochanges in requirements, changes in check-in code, changes in releasedcode, and changes in bug reports or feature requests, as will bediscussed in greater detail in the following paragraphs. One or moreArtificial Intelligence (AI) learning models (102) and a bugpre-detection tool (101) are communicably interfaced to or integratedinto well-known software development tools, as will be discussed ingreater detail in the following paragraphs, too.

To provide the foregoing advantages, embodiments according to thepresent invention will follow these three general phases of operation:

-   -   1. Prior to processing any search for similar software problem        descriptions, a repository of textual descriptions of a history        of changes to the software product would be created by gathering        information (or a collection of links to information) from        different sources such as from bug tracking databases, extracted        comments in source code, and “one liner” comments captured in        software version control systems.    -   2. After the repository has been created, a user would input a        description of the changes he or she is going to make to the        software source code into the comments of an enhanced bug        tracking tool, then he or she would click a button, which would        scan the repository while searching for similar changes made in        the past, using NLP methods to search for matches rather than        just prevalence of keywords and synonyms.    -   3. The results of the NLP-based search would be displayed to the        user, showing similar changes made in the past and indicating        whether the previous changes were found to be problematic (e.g.,        had to be backed out, had to be blocked from inclusion in a        release, had to be patched, etc).

For example, a user could input into the enhanced bug tracking system'suser interface that they are planning to add a hashmap to a softwaredesign or product. Such user input might include a natural languagedescription of what functions would use the hashmap, and what datastructures the hashmap would relate to each other, and to whichparticular method or code module the hashmap would be added, such ascom.my.package.

The resulting NLP-based search might find instances in the past, inwhich hashmaps were used in similar circumstances and caused performanceissues.

Once a repository of defects, comments, and past actions has be created,the system can use Machine Learning to generate models to makesuggestions smarter and more accurate.

In addition to being able to pre-detect coding problems, embodiments ofthe invention will make test case generation and test automationsmarter. Existing work artifacts and test cases will be leveraged toform the core knowledge base (e.g., the repository). Based on thisknowledge base, embodiments of the invention will automatically generatenew test suites (collections of test cases) to run on a selectiveautomation segment that will likely catch a problem, and will suggestwhich test suites or test cases within test suites will unlikely produceuseful results. This will not only save time on running test automation,but will also enhance the efficiency of identifying relevant problems.

Exemplary Embodiment

At least one embodiment according to the present invention provides animprovement and extension to currently-available tools commonly used inSoftware Development efforts, Requirements Tooling, Project Planning,Version Control Systems, and Software Test Tools. For the scope of thisexample embodiment, these tools can be traditionally separate tools,which are well known individually in the art, or they may be toolswithin a Software Lifecycle Management solution, such as IBM's RationalTeam Concert™.

Initializing the Repository. Before the bug pre-detection method andtool of the present invention is used by a user, training data will beingested by the system originating from a variety of sources. This wouldlikely include, but not limited to, defect tracking databases,requirements documents, work items, and test cases generated duringprior releases, as well as comments from known defect-free sections ofcode.

As the development of a new software release begins, requirements mustbe collected. FIG. 2 shows some typical components of natural languagetext, which can be gathered from a requirements document or database(200), including a requirement name, a requirement description, and oneor more discussion entries relating to that requirement. Suchinformation may be digitally represented by plain text documents, wordprocessor documents, database records, eXtensible Markup Language (XML),as well as in other digital format. For example, a requirement for thecompatibility of a software method with an particular standard might berepresented in XML as follows:

<method_requirement>   <method_name> name-of-method </method_name>  <reqmt_name> textual-name-of-requirement </reqmt_name>   <reqmt_descr>“ This is a description in natural language of this   requirement . . .” </reqmt_descr>   <discussion_thread>     <discussion_entry>      <disc_date> 01-01-2013 </disc_date>       <disc_author> R Smith</disc_author>       <disc_body> “I think this requirement may cause        some incompatibilities with XYZ module         because . . . ”</disc_body>     </discuss_entry>     <discussion_entry>      <disc_date> 01-02-2013 </disc_date>       <disc_author> S Yee</disc_author>       <disc_body> “Compatibility should be OK because        XYZ module has an option to . . . ”         </disc_body>    </discuss_entry>     <discussion_entry>       <disc_date> 01-05-2013</disc_date>       <disc_author> R Patel </disc_author>      <disc_body> “I just checked and that option was not        implemented because . . . ”   </disc_body>     </discuss_entry>    . . .   </discussion_thread> </method_requirement>

In this example, one can see that a new requirement is discussed innatural language and its compatibility or incompatibility with anothermodules or methods in the software product. An NLP search engine will beable to find these entries after they are indexed or ingested into therepository.

So, for the purposes of this illustrative example, we will focus on therequirements content describing the requirement and the subsequentdiscussion used to decide whether or not to approve or reject therequirement. Once the requirement document has been saved into therepository (103) (or linked to the repository), the embodiment of theinvention will send the content of that document to the NLP-based bugpre-detection tool to enable impact prediction of future proposerequirements and changes.

Response to New Requirement or Change to a Requirement. The output ofthe NLP-based bug pre-detection tool will be compared with models (102)generated by Machine Learning, as shown in FIG. 3. Please note that inthis embodiment, it is assumed that training data (102) has beenpreviously generated. As continued discussion happens around therequirement, or when the requirement itself is updated (300, 103, 301,302), the new pre-detection tool will continuously send the new orrevised content back through the tool and compare it against the trainedmodels. As content is added or removed from the requirement content, ordiscussion content added, an “intervention” step will be proposed (304),if available, based on previous test case results and/or problemresolutions according to the results of the Natural Language Processing(NLP) search (303). Based on previous knowledge in the form of ourtrained models (102) and, if available, previous bug resolution notes(104), the bug pre-detection tool will offer suggestions in the form ofautomatically-generated discussion comments (301) or other suitablenotices (e-mails, text messages, etc.) as to whether or not theproposals in the latest revision of the document will improve softwarequality in terms of the likelihood of introducing new defects, ortriggering previously solved defects, which is illustrated in FIG. 3.

An added advisory entry to a discussion thread might appear as follows:

<discussion_entry>   <disc_date> 01-07-2013 </disc_date>   <disc_author>Bug Pre-detector </disc_author>   <disc_body> “ADVISORY: The bugpre-detector     tool has found similar changes that resulted     in oneor more bug(s). Description(s) of the     bug(s) and the correctiveaction(s) can be     found at the following hyperlinks . . . ”    <link> link_1 </link>     <link> link_2 </link>     . . .     <link>link_3 </link>   </disc_body> </discuss_entry>

Updating of AI Network. Once the requirement or change to therequirement has been approved, the final content of the requirement willbe sent through the pre-detection tool (104, 401, 402) and, onceannotated (403), will be used to update the training data (102) for theMachine Learning Models, as illustrated in FIG. 4. This allows theapproved intervention to be included in the suggestions for similarrequirements change proposed in the future.

Enhancements to Software Lifecycle Tool. In one embodiment, after thesoftware development has begun, the new tool will apply the samemethodology to the development tasks captured in the same SoftwareLifecycle Management Solution, in which the development originallyoccurred. Assume for the purpose of this illustrative embodiment thatdevelopment tracking and version control tools provide a “two step”delivery mechanism, as previously illustrated in FIG. 1 a.

The first step is referred to as “check-in”, which sends the latest workto the version control system. The second step is referred to as“delivery”, which moves the updated code to the larger, shared versioncontrol repository. This kind of system is not part of the invention,per se, but would be used in the context of implementation of thepresent invention. With each check-in of new or revised source code,that code will be entered into the bug pre-detector tool and tested foradherence to the approved requirement. By having the requirement workitem included as a document in the bug pre-detection corpus, it can bedetected if a developer has deviated from what was agreed upon in therequirements. This will provide an opportunity to have the new SoftwareDevelopment Advisor insert (502, 503, 504) discussion comments into thework items (501) used as part of the software development trackingtools, as illustrated in FIG. 5.

A Complete Lifecycle Optimizer.

Pre-detection of Failures and Suggestions of Solutions. The inventionthereby allows a user to perform automated, unattended code reviewsbased on natural language processing (NLP) and artificial intelligence(AI). In addition to pre-detecting code changes that may deviate anestablished requirement, another unique benefit of some embodiments ofthe present invention is to automatically suggest alternative solutionsbased on modeled predictions around defects, previous performanceissues, or any other past discussions around how to adhere to bestpractices. These all come from the AI Machine Learning models andcaptured comment corpus. For example, if a developer enters adescription of a proposed or recently-made change to the software designto “increase the encryption from 128-bit to 256-bit”, the NLP search mayfind some comments for previous discussion of encryption levels whichidentify the need to export this product and a requirement not to exportcertain levels (or above) of encryption, per legal or regulatorystandards. The new tool, then, would create a link to those oldercomments and discussion entries, and would post them automatically intothe discussion thread where the developer was proposing the new change.In another example, a developer may propose adding a method call to athird-party voice encoding and decoding module for the purposes ofallowing voice annotations to a product's output, but the new tool mayfind using the NLP search that this third-party voice encoding anddecoding module has caused failures in integration testing and field useon multiple occasions, and it may further find comments regarding a“work around” to be to use another supplier's voice encoding anddecoding module. As such, a text entry would be automatically enteredinto the relevant discussion thread, with links to both the potentialproblem comments and the potential work-around comments.

Pre-Selection of Test Cases. Once the source code has been delivered,the new tool can run the delivered code through the bug pre-detectiontool and will only add to the Machine Learning models once it has beensuccessfully tested that the code is defect-free.

As the work item is delivered and built into a software deliverable, thenext phase of some embodiments of the present invention may be engaged.As the code has been previously run through the bug pre-detection tool,the Machine Learning models can be employed to predict a number ofthings including, but not limited to, defects, performance bottlenecks,and most importantly. These identified defects and bottlenecks may thenbe mapped to specific tests that would be most effective in testingthese aspects of the new code. As in the previous example, if the bugpre-detector tool indicates that a change may invoke a voice compressionmodule to record and store a message or voice annotation, then all knownvoice compression module tests may be identified using the new NLPsearch-based tool from an available suite of tests. Further, if aspecific voice compression module is invoked, then test cases which areknown to exercise and stress previously-found weaknesses in thatspecific voice compression module will be selected and suggested forvalidation testing. As in the previous example, if a third-party XYZvoice compression module is reflected in the corpus of comments that itcaused a memory error when recording a voice message over 90 seconds inlength in past versions of the software product, then the new bugpre-detection tool find this by performing NLP searches on the corpus oftest case code and test case description documents, and it wouldsimilarly identify and suggest any test cases which automaticallyattempt to record a message over 90 seconds long to attempt to causethis error (as indicated in the found test code and test case comments).

The effectiveness of different test cases in uncovering defects can beanalyzed and rank-ordered. With adequate training, these models will beequipped to identify the optimal design of test cases for differentcategories of work artifacts. These models can then be applied to newwork artifacts to suggest the most efficient test cases.

As the software product containing the new additions or changes entersregression testing phase of development, a suite or collection of testcases can be dynamically built such that the test cases target thenewly-updated code by leveraging the trained Machine Learning models.After a regression test is completed, the following steps can beperformed:

-   -   (1) If the newly-delivered code passes the test(s), the output        of the bug pre-detection tool for the newly-delivered code will        be added the Machine Learning models to increase the accuracy of        the tool's model.    -   (2) If the test that targets the newly delivered code fails, the        output of the bug pre-detection tool will be added to the tool's        model as a more reliable example of the features found in the        code delivery. This will allow the models to become even more        effective, even when the test fails.

A failed test will only be added to the Machine Learning models if it isdetermined that it was the product that failed, not that the test faileddue to it being incompatible with the version of the product beingtested.

By applying these methods to a software development program, we canincrease code and test quality automatically.

Suitable Computing Platform

The preceding paragraphs have set forth example logical processesaccording to the present invention, which, when coupled with processinghardware, embody systems according to the present invention, and which,when coupled with tangible, computer readable memory devices, embodycomputer program products according to the related invention.

Regarding computers for executing the logical processes set forthherein, it will be readily recognized by those skilled in the art that avariety of computers are suitable and will become suitable as memory,processing, and communication capacities of computers and portabledevices increase. In such embodiments, the operative invention includesthe combination of programmable computing platform and programs. Inother embodiments, some or all of the logical processes may be committedto dedicated or specialized electronic circuitry, such as ApplicationSpecific Integrated Circuits or programmable logic devices.

The present invention may be realized for many different processors usedin many different computing platforms. FIG. 6 illustrates a generalizedcomputing platform (600), such as common and well-known computingplatforms such as “Personal Computers”, web servers such as an IBMiSeries™ server, and portable devices such as personal digitalassistants and smart phones, running a popular operating systems (602)such as Microsoft™ Windows™ or IBM™ AIX™, UNIX, LINUX, Google Android™,Apple iOS™, and others, may be employed to execute one or moreapplication program(s) to accomplish the computerized methods describedherein. Whereas these computing platforms and operating systems are wellknown and openly described in any number of textbooks, websites, andpublic “open” specifications and recommendations, diagrams and furtherdetails of these computing systems in general (without the customizedlogical processes of the present invention) are readily available tothose ordinarily skilled in the art.

Many such computing platforms, but not all, allow for the addition of orinstallation of application programs (601), which provide specificlogical functionality and, which allow the computing platform to bespecialized in certain manners to perform certain jobs, thus renderingthe computing platform into a specialized machine. In some “closed”architectures, this functionality is provided by the manufacturer andmay not be modifiable by the end-user.

The “hardware” portion of a computing platform typically includes one ormore processors (604) accompanied by, sometimes, specializedco-processors or accelerators, such as graphics accelerators, and bysuitable computer readable memory devices (RAM, ROM, disk drives,removable memory cards, etc.). Depending on the computing platform, oneor more network interface(s) (605) may be provided, as well as specialtyinterfaces for specific applications. If the computing platform isintended to interact with human users, it is provided with one or moreuser interface device(s) (607), such as displays, keyboards, pointingdevices, speakers, etc. And, each computing platform requires one ormore power supplies (battery, AC mains, solar, etc.).

Conclusion

The terminology used herein is for the purpose of describing particularembodiments only and is not intended to be limiting of the invention. Asused herein, the singular forms “a”, “an” and “the” are intended toinclude the plural forms as well, unless the context clearly indicatesotherwise. It will be further understood that the terms “comprises”and/or “comprising,” when used in this specification, specify thepresence of stated features, steps, operations, elements, and/orcomponents, but do not preclude the presence or addition of one or moreother features, steps, operations, elements, components, and/or groupsthereof, unless specifically stated otherwise.

The corresponding structures, materials, acts, and equivalents of allmeans or step plus function elements in the claims below are intended toinclude any structure, material, or act for performing the function incombination with other claimed elements as specifically claimed. Thedescription of the present invention has been presented for purposes ofillustration and description, but is not intended to be exhaustive orlimited to the invention in the form disclosed. Many modifications andvariations will be apparent to those of ordinary skill in the artwithout departing from the scope and spirit of the invention. Theembodiment was chosen and described in order to best explain theprinciples of the invention and the practical application, and to enableothers of ordinary skill in the art to understand the invention forvarious embodiments with various modifications as are suited to theparticular use contemplated.

It should also be recognized by those skilled in the art that certainembodiments utilizing a microprocessor executing a logical process mayalso be realized through customized electronic circuitry performing thesame logical process(es).

It will be readily recognized by those skilled in the art that theforegoing example embodiments do not define the extent or scope of thepresent invention, but instead are provided as illustrations of how tomake and use at least one embodiment of the invention. The followingclaims define the extent and scope of at least one invention disclosedherein.

What is claimed is:
 1. A method for automatic pre-detection of potentialsoftware product impact and recommendation for resolutions, the methodcomprising the steps of: extracting, by a computer processor, symbolsfrom an input phrase expressed in natural language containing adescription of an unimplemented software project change; receiving, by acomputer processor, from a repository of historical software projectchanges and associated effects on the extracted symbols, one or moreeffects attributed to historical software project changes according tothe extracted symbols; predicting, by a computer processor, one or morecomponents of the software project which will be impacted according tothe received one or more effects; and associating, by a computerprocessor, an advisory notice according to the prediction with the inputphrase in a software development tool; and responsive to receipt of userapproval of the advisory notice, updating, by a computer processor, oneor more machine learning models.
 2. The method as set forth in claim 1wherein the input phrase comprises a proposed change to the softwareproduct, and wherein the advisory comprises a warning of a softwareerror likely to be induced by programming changes corresponding to theproposed change.
 3. The method as set forth in claim 2 wherein thewarning further comprises a suggestion for an alternative changeproposition.
 4. The method as set forth in claim 1 wherein the inputphrase comprises a proposed requirement for the software product, andwherein the advisory comprises a warning of a noncompliance with anotherrequirement likely to be induced by programming changes corresponding tothe proposed requirement.
 5. The method as set forth in claim 1 whereinthe input phrase comprises a description of an untested revision thesoftware product, and wherein the warning comprises a suggestion of oneor more test cases to be employed to regression test and validate therevision of the software product.
 6. The method as set forth in claim 5wherein the test case advisory comprises one or more advisories selectedfrom the group consisting of a recommended applicable test case, anon-recommended inapplicable test case, and a modified test suite of aplurality of recommended test cases.
 7. The method as set forth in claim1 further comprising, responsive to user indication of approval of theimpact prediction, updating by the computer processor one or moremachine learning models.
 8. A computer program product for automaticpre-detection of potential software product impact and recommendationfor resolutions comprising: a tangible, computer readable storage memorydevice which is not a propagating signal per se; and programinstructions embodied by the memory device for causing a processor, whenexecuted, to: extract symbols from an input phrase expressed in naturallanguage containing a description of an unimplemented software projectchange; receive from a repository of historical software project changesand associated effects on the extracted symbols, one or more effectsattributed to historical software project changes according to theextracted symbols; predict one or more components of the softwareproject which will be impacted according to the received one or moreeffects; and associate an advisory notice according to the predictionwith the input phrase in a software development tool; and responsive toreceipt of user approval of the advisory notice, update one or moremachine learning models.
 9. The computer program product as set forth inclaim 8 wherein the input phrase comprises a proposed change to thesoftware product, and wherein the advisory comprises a warning of asoftware error likely to be induced by programming changes correspondingto the proposed change.
 10. The computer program product as set forth inclaim 9 wherein the warning further comprises a suggestion for analternative change proposition.
 11. The computer program product as setforth in claim 8 wherein the input phrase comprises a proposedrequirement for the software product, and wherein the advisory comprisesa warning of a noncompliance with another requirement likely to beinduced by programming changes corresponding to the proposedrequirement.
 12. The computer program product as set forth in claim 8wherein the input phrase comprises a description of an untested revisionthe software product, and wherein the warning comprises a suggestion ofone or more test cases to be employed to regression test and validatethe revision of the software product.
 13. The computer program productas set forth in claim 12 wherein the test case advisory comprises one ormore advisories selected from the group consisting of a recommendedapplicable test case, a non-recommended inapplicable test case, and amodified test suite of a plurality of recommended test cases.
 14. Thecomputer program product as set forth in claim 8 wherein the programinstructions further comprise instructions, responsive to userindication of approval of the impact prediction, to update one or moremachine learning models.
 15. A system for automatic pre-detection ofpotential software product impact and recommendation for resolutionscomprising: a computing platform having a processor and a computerreadable storage memory device; a tangible, computer readable storagememory device which is not a propagating signal per se; and programinstructions embodied by the memory device for causing the processor,when executed, to: extract symbols from an input phrase expressed innatural language containing a description of an unimplemented softwareproject change; receive from a repository of historical software projectchanges and associated effects on the extracted symbols, one or moreeffects attributed to historical software project changes according tothe extracted symbols; predict one or more components of the softwareproject which will be impacted according to the received one or moreeffects; and associate an advisory notice according to the predictionwith the input phrase in a software development tool; and responsive toreceipt of user approval of the advisory notice, update one or moremachine learning models
 16. The system as set forth in claim 15 whereinthe input phrase comprises a proposed change to the software product,and wherein the advisory comprises a warning of a software error likelyto be induced by programming changes corresponding to the proposedchange.
 17. The system as set forth in claim 15 wherein the input phrasecomprises a proposed requirement for the software product, and whereinthe advisory comprises a warning of a noncompliance with anotherrequirement likely to be induced by programming changes corresponding tothe proposed requirement.
 18. The system as set forth in claim 15wherein the input phrase comprises a description of an untested revisionthe software product, and wherein the warning comprises a suggestion ofone or more test cases to be employed to regression test and validatethe revision of the software product.
 19. The system as set forth inclaim 18 wherein the test case advisory comprises one or more advisoriesselected from the group consisting of a recommended applicable testcase, a non-recommended inapplicable test case, and a modified testsuite of a plurality of recommended test cases.
 20. The system as setforth in claim 15 wherein the program instructions further compriseinstructions to, responsive to user indication of approval of the impactprediction, update one or more machine learning models.